package qc.module.ehs.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.exception.QCPromptException;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.common.core.utils.DateUtil;
import qc.common.core.utils.IdentifierUtil;
import qc.module.ehs.dto.certificate.CertificateDto;
import qc.module.ehs.dto.certificate.CertificateQueryConditionDto;
import qc.module.ehs.entity.EhsCertificateInfo;
import qc.module.ehs.mapper.EhsCertificateInfoMapper;
import qc.module.ehs.repository.EhsCertificateInfoRepository;

import java.util.Date;
import java.util.List;
import java.util.Objects;

/**
 * EhsCertificateInfoService
 * @author YRR
 * @create 2025-03-11 13:44
 */
@Service
public class EhsCertificateInfoService {
    @Autowired
    private EhsCertificateInfoRepository repository;

    /**
     * 查询资质证照信息
     * @param dto 查询条件dto
     * @return List<CertificateDto>
     * @throws QCPromptException
     */
    public List<CertificateDto> query(CertificateQueryConditionDto dto) throws QCPromptException {
        //1、证照新判断
        if (dto == null) throw new QCPromptException("资质证照的查询条件信息不能为空");
        if (StringUtils.isBlank(dto.getOrgcode())) throw new QCPromptException("资质证照的组织代码不能为空");

        //2、添加必须得查询条件
        LambdaQueryWrapper<EhsCertificateInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsCertificateInfo::getOrgcode, dto.getOrgcode());
        wrapper.eq(EhsCertificateInfo::getIsepiboly, dto.isIsepiboly());

        //3、证书类型查询(单位证照=1、人员证照=2、其他或为空表示全部)
        if (StringUtils.isNotBlank(dto.getHoldtype())) {
            if (dto.getHoldtype().equals("1")) {
                wrapper.eq(EhsCertificateInfo::getIsperson, false);
            } else if (dto.getHoldtype().equals("2")) {
                wrapper.eq(EhsCertificateInfo::getIsperson, true);
            }
        }

        //4、查询证书的状态（有效=1、过期=0，为空全部其他表示全部）
        if (StringUtils.isNotBlank(dto.getStatus())) {
            if (dto.getStatus().equals("0")) {
                wrapper.le(EhsCertificateInfo::getExpiredtm, DateUtil.getNowDate());
            } else if (dto.getStatus().equals("1")) {
                wrapper.and(w -> w
                        .gt(EhsCertificateInfo::getExpiredtm, DateUtil.getNowDate())
                        .or()
                        .isNull(EhsCertificateInfo::getExpiredtm));
            }
        }
        //5、相关方id查询
        if (StringUtils.isNotBlank(dto.getEpiboly())) {
            wrapper.eq(EhsCertificateInfo::getHolduserid, dto.getEpiboly());
        }

        //6、关键字查询
        if (StringUtils.isNotBlank(dto.getKeywords())) {
            String keywords = dto.getKeywords();
            wrapper.and(w -> w.like(EhsCertificateInfo::getName, keywords)
                    .or().like(EhsCertificateInfo::getType, keywords)
                    .or().like(EhsCertificateInfo::getNo, keywords)
                    .or().like(EhsCertificateInfo::getAssigntm, keywords)
                    .or().like(EhsCertificateInfo::getHoldusername, keywords)
            );
        }

        //7、查询排序
        wrapper.orderByAsc(EhsCertificateInfo::getName);

        List<EhsCertificateInfo> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) {
            return EhsCertificateInfoMapper.MAPPER.toDtoList(ens);
        }
        return null;
    }

    /**
     * 添加资质证照信息
     * @param dto 新增的信息
     * @return 成功返回null，失败返回错误或提示信息
     * @throws QCPromptException
     */
    public String add(CertificateDto dto) {
        //1、信息判空
        if (dto == null) return QCUnifyReturnValue.Warn("资质证照的添加信息不能为空");
        if (StringUtils.isBlank(dto.getOrgcode())) return QCUnifyReturnValue.Warn("资质证照的组织代码不能为空");
        if (StringUtils.isBlank(dto.getName())) return QCUnifyReturnValue.Warn("资质证照的名称不能为空");

        Date assigntm = null;
        Date expiredtm = null;

        //2、判断发证日期格式
        if (StringUtils.isNotBlank(dto.getAssigntm())) {
            assigntm = DateUtil.parseDate(dto.getAssigntm());
            if (assigntm == null) {
                return QCUnifyReturnValue.Warn("资质证照的发证日期格式不正确");
            }
        }

        //3、判断过期日期格式
        if (StringUtils.isNotBlank(dto.getExpiredtm())) {
            expiredtm = DateUtil.parseDate(dto.getExpiredtm());
            if (expiredtm == null) {
                return QCUnifyReturnValue.Warn("资质证照的过期时间日期格式不正确");
            }
        }

        //4、dto -> entity
        EhsCertificateInfo entity = EhsCertificateInfoMapper.MAPPER.toEntity(dto);
        entity.setAssigntm(assigntm);
        entity.setExpiredtm(expiredtm);
        entity.setId(IdentifierUtil.randomUUID());
        //5、判断数据是否成功添加
        if (repository.insert(entity) < 0x1)
            return QCUnifyReturnValue.Warn("资质证照的新增数据失败");
        return QCUnifyReturnValue.Success();
    }

    /**
     * 修改证照信息
     * @param dto 修改对象DTO
     * @return 成功返回null, 失败返回错误或提示信息
     */
    public String update(CertificateDto dto) {
        //1、信息判空
        if (dto == null) return QCUnifyReturnValue.Warn("资质证照的信息不能为空");
        if (StringUtils.isBlank(dto.getId())) return QCUnifyReturnValue.Warn("资质证照的证书ID不能为空");
        if (StringUtils.isBlank(dto.getOrgcode())) return QCUnifyReturnValue.Warn("资质证照的组织代码不能为空");
        if (StringUtils.isBlank(dto.getName())) return QCUnifyReturnValue.Warn("资质证照的证书名称不能为空");

        //2、校验修改证书的id是否存在
        if (!isCertificateExist(dto.getId())) {
            return QCUnifyReturnValue.Warn("资质证照的修改的证书id不存在");
        }

        Date assigntm = null;
        Date expiredtm = null;

        //4、判断发证日期格式
        if (StringUtils.isNotBlank(dto.getAssigntm())) {
            assigntm = DateUtil.parseDate(dto.getAssigntm());
            if (assigntm == null) {
                return QCUnifyReturnValue.Warn("资质证照的修改的发证日期格式不正确");
            }
        }

        //5、判断过期日期格式
        if (StringUtils.isNotBlank(dto.getExpiredtm())) {
            expiredtm = DateUtil.parseDate(dto.getExpiredtm());
            if (expiredtm == null) {
                return QCUnifyReturnValue.Warn("资质证照的修改过期时间格式不正确");
            }
        }

        //dto -> entity
        EhsCertificateInfo entity = EhsCertificateInfoMapper.MAPPER.toEntity(dto);
        entity.setAssigntm(assigntm);
        entity.setExpiredtm(expiredtm);
        //6、判断是否修改成功
        if (repository.updateById(entity) < 0x1)
            return QCUnifyReturnValue.Warn("资质证照的信息修改失败");
        return QCUnifyReturnValue.Success();
    }

    /**
     * 删除指定资质证照的信息
     * @param id 资质证照id
     * @return 成功返回null，失败返回错误或提示信息
     */
    public String delete(String id) {
        //1、判断数据是否存在
        if (repository.deleteById(id) < 0x1)
            return QCUnifyReturnValue.Warn("删除的资质证照数据不存在");
        return QCUnifyReturnValue.Success();
    }

    /**
     * 获取指定的资质证照的信息
     * @param id 资质证照id
     * @return CertificateDto
     * @throws QCPromptException
     */
    public CertificateDto get(String id) {
        //1、判断数据是否存在
        EhsCertificateInfo entity = repository.selectById(id);
        if (Objects.nonNull(entity)) {
            return EhsCertificateInfoMapper.MAPPER.toDto(entity);
        }
        return null;
    }

    /**
     * 判断资质证照id是否存在
     * @param id
     * @return boolean
     * @throws QCPromptException
     */
    boolean isCertificateExist(String id) {
        EhsCertificateInfo entity = repository.selectById(id);
        if (Objects.nonNull(entity)) {
            return true;
        }
        return false;
    }
}



